home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / stut_src / iofields.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-27  |  28.8 KB  |  1,258 lines
  1. /*
  2.  * IoFields.c
  3.  *
  4.  * Purpose:
  5.  * -------- 
  6.  * Routines de traitement des champs de saisie/sortie
  7.  *
  8.  * History:
  9.  * --------
  10.  * 09.12.94: fplanque: Created
  11.  */
  12.  
  13.  
  14.      #include "!OPTIONS.H"                /* Options de compilation */         
  15.     #define    THIS_FILE    "IOFIELDS.C v1.00 - 03.95"
  16.           
  17.  
  18. /*
  19.  * System headers:
  20.  */
  21.     #include    <stdio.h>                    /* header standard */
  22.     #include <string.h>                    /* header tt de chaines */
  23.    
  24.  
  25. /*
  26.  * Custom headers:
  27.  */
  28.     #include "SPEC_PU.H"
  29.     #include "S_MALLOC.H"
  30.     #include    "SERV_PU.H"
  31.     #include    "LINE0_PU.H"
  32.     #include    "DBINT_PU.H"        /* DB Interface */
  33.     #include    "DEBUG_PU.H"    
  34.     #include "DBSYS_PU.H"
  35.     #include "TEXT_PU.H"
  36.     #include "TERM_PU.H"
  37.     #include "MAIN_PU.H"
  38.     #include "DEF_ARBO.H"
  39.     #include "IOFLD_PU.H"
  40.     
  41. /*
  42.  * ---------------------------- METHODES --------------------------
  43.  */
  44.  
  45.  
  46. /*
  47.  * GetEditMode(-)
  48.  *
  49.  * Purpose:
  50.  * --------
  51.  * D‚termine le mode d'‚dition de la voie en question
  52.  *
  53.  * History:
  54.  * --------
  55.  * 10.05.94: fplanque: Created
  56.  * 21.08.94: fplanque: se base maintenant sur pIOField_CurrIn
  57.  * 12.07.95: fplanque: chang‚ de IsEditing() en GetEditMode()
  58.  */
  59. EDIT_MODE    GetEditMode(                /* Out: Mode d'‚dition courant de la voie concern‚e */
  60.                     VOIE *pVoie_curr )    /* In:  Ptr sur voie courante */
  61. {
  62.     if( pVoie_curr -> curr_textline == NULL )
  63.     {    /*
  64.          * On ne peut mˆme pas stocker les donn‚es re‡ues,
  65.          * donc interaction de base:
  66.          */
  67.         return    BASIC;
  68.     }
  69.  
  70.     if( pVoie_curr -> pIOField_CurrIn == NULL )
  71.     {    /*
  72.          * Pas de descripteur de champ,
  73.          * donc on ne peut que stocker sans edition avanc‚e:
  74.          */
  75.         return     BUFFERING;
  76.     }
  77.     
  78.     /*
  79.      * Edition complŠte:
  80.      */
  81.     return    FIELDEDIT;
  82. }
  83.  
  84.  
  85. /*
  86.  * get_InFieldPars(-)
  87.  *
  88.  * Purpose:
  89.  * --------
  90.  * Cherche champ demand‚ dans la voie courante 
  91.  * et renvoie ptr sur ses paramŠtres
  92.  *
  93.  * History:
  94.  * --------
  95.  * 24.11.94: fplanque: Created
  96.  */
  97. FLD_STATUS get_InFieldPars(                 /* Out: FLD_NOT_FOUND, FLD_DISABLED ou FLD_READY */
  98.                 VOIE         *    pVoie_curr,        /* In:  Voie concern‚e */
  99.                 int            n_fnct,            /* In:  Fonction recherch‚e */
  100.                 IOFIELD **    ppInField )        /* Out: ptr sur params ou NULL si pas trouv‚ */
  101. {
  102.     /* 
  103.      * Variables: 
  104.      */
  105.     IOFIELD    *    pIOField_CurrIn;
  106.     int             index;
  107.  
  108.     /*
  109.      * Cherche le champ d‚sir‚: 
  110.      */
  111.     for( pIOField_CurrIn = pVoie_curr -> pIOField_ListIn, index=1 ;
  112.             pIOField_CurrIn != NULL; pIOField_CurrIn = pIOField_CurrIn -> p_next, index++ )
  113.     {
  114.         if( pIOField_CurrIn -> FPar.Input -> fnct_no == n_fnct )
  115.         {    /*
  116.              * Si trouv‚ champ de fonction demand‚e:
  117.              */
  118.             *ppInField = pIOField_CurrIn;
  119.             if( pIOField_CurrIn -> FPar.Input -> InFieldFlags .b_enabled )
  120.             {
  121.                 return    FLD_READY;
  122.             }
  123.             
  124.             return    FLD_DISABLED;
  125.         }
  126.     }
  127.     
  128.     *ppInField = NULL;
  129.     return        FLD_NOT_FOUND;
  130. }
  131.  
  132.  
  133.  
  134.  
  135. /*
  136.  * Create_ArboPageInFieldList(-)
  137.  *
  138.  * Purpose:
  139.  * --------
  140.  * Init des champs d'‚dition de la page courante sur la voie d‚sir‚e
  141.  *
  142.  * Algorythm:
  143.  * ----------  
  144.  * - Cr‚ation d'une liste chain‚e des champs de saisie avec ptrs sur
  145.  *   PARAMS d'affichage ET BUFFERS de saisie
  146.  *
  147.  * History:
  148.  * --------
  149.  * 1993: fplanque: Created
  150.  * 21.08.94: cr‚ation de la liste de INFIELDs
  151.  * 27.11.94: plus d'affichage des champs cr‚‚s
  152.  * 05.12.94: ne m‚morise que les champs activ‚s; DOUBLE CHAINAGE!
  153.  * 17.12.94: gestion champ scrollable
  154.  */
  155. void    Create_ArboPageInFieldList( 
  156.             VOIE *    pVoie_curr )        /* In: Voie concern‚e */
  157. {
  158.     IOFIELD            **    ppInFields_prevnext = &(pVoie_curr -> pIOField_ListIn); 
  159.     IOFIELD            *    pIOField_CurrIn;        
  160.     IOFIELD            *    pInField_Previous    = NULL;
  161.     PAGEARBO         *    curr_arboparams    = pVoie_curr -> arboparams;
  162.     ARBO_FIELDPARS    *    pFieldPars_Curr     = curr_arboparams -> input_fields;    
  163.  
  164.     /*
  165.      * V‚rifie que la liste des champs d'entr‚e est vide:
  166.      */
  167.     if( pVoie_curr -> pIOField_ListIn != NULL )
  168.     {
  169.         signale( "Liste des champs d'entr‚e non initialis‚e!" );
  170.     }
  171.  
  172.     /*
  173.      * Parcourt les champs: 
  174.      */
  175.     while( pFieldPars_Curr != NULL )
  176.     {
  177.         if( pFieldPars_Curr -> data.input .InFieldFlags.b_enabled == TRUE_1 )
  178.         {    /*
  179.              * Si champ est activ‚:
  180.              * Cr‚e un bloc de paramŠtres pour ce champ de saisie:
  181.              */
  182.             pIOField_CurrIn = (IOFIELD *) MALLOC( sizeof( IOFIELD ) );
  183.  
  184.             /*
  185.              * linkage PARAMS d'affichage: 
  186.              */
  187.             pIOField_CurrIn -> FPar.Input = &(pFieldPars_Curr -> data.input);
  188.  
  189.             /*
  190.              * CREATION et linkage d'une ZONE m‚moire pour l'‚dition: 
  191.              */
  192.             pIOField_CurrIn -> pTextInfo = create_textedit_zone( );
  193.  
  194.             /*
  195.              * M‚morise ligne au top de la zone d'affichage:
  196.              */
  197.             pIOField_CurrIn -> pTextLine_Top = pIOField_CurrIn -> pTextInfo -> firstline -> next;
  198.             pIOField_CurrIn -> l_TopLine         = 1;        /* On est sur la ligne no 1 */
  199.  
  200.             /* 
  201.              * Chainage de la liste:
  202.              */
  203.             *ppInFields_prevnext = pIOField_CurrIn;
  204.             pIOField_CurrIn -> p_prev = pInField_Previous;
  205.             
  206.             /*
  207.              * Pour le linkage du champ suivant:
  208.              */
  209.             pInField_Previous = pIOField_CurrIn;
  210.             ppInFields_prevnext = &( pInField_Previous -> p_next );
  211.     
  212.         }
  213.  
  214.         /*
  215.          * Passe au champ suivant: 
  216.          */
  217.         pFieldPars_Curr = pFieldPars_Curr -> next;
  218.     }
  219.  
  220.     /*
  221.      * Fin de liste chaŒn‚e:
  222.      */
  223.     *ppInFields_prevnext = NULL;
  224. }
  225.  
  226.  
  227. /*
  228.  * display_field(-)
  229.  *
  230.  * Purpose:
  231.  * --------
  232.  * Affiche un champ d'‚dition sur le minitel
  233.  * texte + car d'appel … la SAISIE
  234.  * limites top et bottom
  235.  *
  236.  * History:
  237.  * --------
  238.  * 21.08.94: fplanque: Created
  239.  * 22.08.94: IntŠgre maintenant un clipping vertical
  240.  * 17.12.94: gestion champ scrollable
  241.  * 18.12.94: Correction du bug de placement des caractŠres d'info sur continuit‚ des Ý
  242.  * 08.01.95: affiche les champs crypt‚s; corrig‚ bug fill pour champ … 1 seul car
  243.  */
  244. void    display_field(
  245.             int            device,    
  246.             IOFIELD    *    pIOField_In,    /* In: ptr sur champ … afficher */
  247.             int            n_ClipTop,    /* In: Limite sup‚rieure pour l'affichage */
  248.             int            n_ClipBot )    /* In: Limite inf‚ieure pour l'affichage */
  249. {
  250.     /*
  251.      * ParamŠtres d'affichage:
  252.      */
  253.     INPUT_FPAR        *    pInputFPar_Curr = pIOField_In -> FPar.Input;
  254.     TEXTLINE            *    pTextLine          = pIOField_In -> pTextLine_Top;
  255.  
  256.     int    x, y;            
  257.     int    fill;            /* Support d'‚criture */
  258.     int    text_length;
  259.     int    n_line_length = pInputFPar_Curr -> w;
  260.     BOOL    b_MultiParagraph = pInputFPar_Curr -> InFieldFlags.b_MultiParagraph;
  261.     int    n_AscCache = pInputFPar_Curr -> asc_cach;
  262.  
  263.     /*
  264.      * Init Variables: 
  265.      */
  266.     x        = pInputFPar_Curr -> x;                /* Position x */
  267.     fill    = pInputFPar_Curr -> asc_fill;        /* Support */
  268.  
  269.     for ( y = pInputFPar_Curr -> y; 
  270.             y < (pInputFPar_Curr -> y + pInputFPar_Curr -> h)
  271.             && y <= n_ClipBot;
  272.             y++ )
  273.     {
  274.         if( y >= n_ClipTop )
  275.         {    /*
  276.              * S'il faut afficher:
  277.              * Positionne le curseur: 
  278.              */
  279.             pos( device, x, y );
  280.     
  281.             text_length = 0;
  282.     
  283.             /*
  284.              * Affiche texte:
  285.              */
  286.             if( pTextLine != NULL )
  287.             {
  288.                 text_length = pTextLine -> length;
  289.                 if( text_length > 0 )
  290.                 {
  291.                     set_tcolor( device, pInputFPar_Curr -> col_text );    /* Couleur texte */
  292.                     if( n_AscCache )
  293.                     {
  294.                         mconout( device, n_AscCache, text_length );
  295.                     }
  296.                     else
  297.                     {
  298.                         str_conout( device, pTextLine -> text );
  299.                     }
  300.                 }
  301.             }
  302.     
  303.             /*
  304.              * Affiche Fin de ligne & support: 
  305.              */
  306.             if( text_length < n_line_length )
  307.             {
  308.                 set_tcolor( device, pInputFPar_Curr -> col_fill );    /* Couleur support */
  309.     
  310.                 if( pTextLine == NULL )
  311.                 {
  312.                     cconout( device, fill );
  313.                 }
  314.                 else if( pTextLine -> info1.continued )
  315.                 {    /*
  316.                      * Le paragraphe continue sur la ligne suivante:
  317.                      */
  318.                     cconout( device, PARAGRAPH_CONT );    
  319.                 }
  320.                 else if( b_MultiParagraph )
  321.                 {    /*
  322.                      * Cette ligne marque la fin d'un paragraphe:
  323.                      * On affiche une marque uniquement en mode multi paragrapphes:
  324.                      */
  325.                     cconout( device, PARAGRAPH_STOP );    
  326.                 }
  327.                 else
  328.                 {    /*
  329.                      * Mode mono paragraphe:
  330.                      */
  331.                     cconout( device, fill );
  332.                 }
  333.                 
  334.                 if( fill >= ' ' )
  335.                 {    /*
  336.                      * S'il y a un support: 
  337.                      */
  338.                     mconout( device, fill, n_line_length - text_length -1 );        /* Affiche support */
  339.                 }
  340.             }
  341.         }
  342.         
  343.         if( pTextLine != NULL )
  344.         {    /*
  345.              * Passe … la ligne suivante:
  346.              */
  347.             pTextLine = pTextLine -> next;
  348.         }
  349.     }
  350. }
  351.  
  352.  
  353.  
  354. /*
  355.  * start_fieldedit(-)
  356.  *
  357.  * Purpose:
  358.  * --------
  359.  * D‚but de l'‚dition d'un champ pour la voie d‚sir‚e
  360.  *
  361.  * Algorythm:
  362.  * ----------  
  363.  * - Si ptr sur champ == NULL : Cherche champ demand‚
  364.  * - initialise edition pour ce champ
  365.  *
  366.  * History:
  367.  * --------
  368.  * 1993: fplanque: Created
  369.  * 21.08.94: fplanque: utilise d‚sormais la liste de INFIELDs
  370.  * 13.11.94: cherche le champ de fonction demand‚e
  371.  * 16.11.94: d‚tection fonction inconnue
  372.  * 24.11.94: mini modif
  373.  * 27.11.94: affichage du champ lorsqu'on s'y place
  374.  * 05.12.94: don't care about the 'field index' any longer
  375.  * 17.12.94: gestion champ scrollable
  376.  * 05.01.94: recoit le champ demand‚ en paramŠtre
  377.  */
  378. int    start_fieldedit(                             /* Out:    FALSE si OK */
  379.                 VOIE         *    pVoie_curr,            /* In:    Voie concern‚e */
  380.                 int            n_fnct,                /* In:    Fonction de champ recherch‚e si pas de ptr direct sur champ */
  381.                 IOFIELD    *    pIOField_CurrIn )    /* In:    Ptr sur champ voulu si connu, NULL sinon: ds ce cas on cherche avec le no de fnct */
  382. {
  383.     if( pIOField_CurrIn == NULL )
  384.     {    /*
  385.         * Cherche le champ d‚sir‚: 
  386.           */
  387.         for( pIOField_CurrIn = pVoie_curr -> pIOField_ListIn;
  388.                 pIOField_CurrIn != NULL;
  389.                  pIOField_CurrIn = pIOField_CurrIn -> p_next )
  390.         {
  391.             if( pIOField_CurrIn -> FPar.Input -> fnct_no == n_fnct )
  392.             {    /*
  393.                  * Si trouv‚ champ de fonction demand‚e:
  394.                  */
  395.                 break;
  396.             }
  397.         }
  398.         
  399.         if( pIOField_CurrIn == NULL )
  400.         {    /*
  401.              * PROBLEME: Champ introuvable:
  402.              */
  403.             ping();
  404.             add_textinf( pVoie_curr -> wi_params, "BUG: Fonction INPUT inconnue!" );
  405.         
  406.             return    ERROR_1;        /* Break! */
  407.         
  408.         }
  409.     }
  410.     
  411.     /*
  412.      * M‚morise nouveau champ de saisie courant: 
  413.      */
  414.     pVoie_curr -> pIOField_CurrIn = pIOField_CurrIn;
  415.  
  416.     /*
  417.      * Affichage du champ sur le Minitel:
  418.      */
  419.     display_field( pVoie_curr -> device, pIOField_CurrIn, 0, 1000 );
  420.  
  421.     /*
  422.      * Ligne en cours d'‚dition
  423.      * (ligne actuellement affich‚e au top de la zone d'‚dition)
  424.      */
  425.     pVoie_curr -> curr_textline = pIOField_CurrIn -> pTextLine_Top;
  426.     pVoie_curr -> l_CurrLine     = pIOField_CurrIn -> l_TopLine;
  427.     
  428.     pVoie_curr -> csr_x = pIOField_CurrIn -> FPar.Input -> x +    pVoie_curr -> curr_textline -> length;
  429.     pVoie_curr -> csr_y = pIOField_CurrIn -> FPar.Input -> y;
  430.  
  431.     return    FALSE0;
  432.     
  433. }
  434.  
  435.  
  436.  
  437. /*
  438.  * Move_FocusToFirstInField(-)
  439.  *
  440.  * Purpose:
  441.  * --------
  442.  * Se d‚place vers le PREMIER champ de saisie activ‚ de la page
  443.  * en affichant la page vid‚otex associ‚e au passage
  444.  *
  445.  * Suggest:
  446.  * --------
  447.  * Am‚liorer le systŠme register_acrion: ajouter des paramŠtres
  448.  *
  449.  * History:
  450.  * --------
  451.  * 05.12.94: fplanque: Created
  452.  */
  453. void    Move_FocusToFirstInField(
  454.                 VOIE     *    pVoie_curr )    /* In: Voie concern‚e */
  455. {
  456.     if( pVoie_curr -> pIOField_ListIn != NULL )
  457.     {    /*
  458.          * S'il y a un champ, on demande l'entr‚e ds ce champ:
  459.          */
  460.         register_action( pVoie_curr, DISP, pVoie_curr -> pIOField_ListIn -> FPar.Input -> fnct_no, 0, NULL );        
  461.         register_action( pVoie_curr, EFLD, 0, 0, pVoie_curr -> pIOField_ListIn );        
  462.     }
  463.  
  464.     /*
  465.      * Repasse en mode d'attente d'action:
  466.      */
  467.     register_action( pVoie_curr, WAIT, 0, 0, NULL );
  468. }
  469.  
  470.  
  471.  
  472. /*
  473.  * Move_FocusToNextInField(-)
  474.  *
  475.  * Purpose:
  476.  * --------
  477.  * Se d‚place vers le PROCHAIN champ de saisie activ‚ de la page
  478.  * en affichant la page vid‚otex associ‚e au passage
  479.  *
  480.  * Suggest:
  481.  * --------
  482.  * Am‚liorer le systŠme register_acrion: ajouter des paramŠtres
  483.  *
  484.  * History:
  485.  * --------
  486.  * 05.12.94: fplanque: Created
  487.  * 05.01.94: profite du des params ACTION
  488.  */
  489. void    Move_FocusToNextInField(
  490.                 VOIE     *    pVoie_curr )    /* In: Voie concern‚e */
  491. {
  492.     if( pVoie_curr -> pIOField_CurrIn != NULL )
  493.     {    /*
  494.          * S'il y a au moins un champ d'‚dition:
  495.          */
  496.         IOFIELD    *    pInField_Target = pVoie_curr -> pIOField_CurrIn -> p_next;
  497.  
  498.         if( pInField_Target != NULL )
  499.         {    /*
  500.              * S'il y a un autre champ aprŠs, 
  501.              * on demande d'afficher la page vdt correspondante et d'y aller:
  502.              */
  503.             register_action( pVoie_curr, DISP, pInField_Target -> FPar.Input -> fnct_no, 0, NULL );        
  504.             register_action( pVoie_curr, EFLD, 0, 0, pInField_Target );        
  505.         }
  506.         else
  507.         {    /*
  508.              * On est sur le dernier champ:
  509.              * On le signale:
  510.              */
  511.             aff_msg_l0( pVoie_curr, "Dernier champ de saisie!" );
  512.         }
  513.     }
  514.  
  515.     /*
  516.      * Repasse en mode d'attente d'action:
  517.      */
  518.     register_action( pVoie_curr, WAIT, 0, 0, NULL );
  519. }
  520.  
  521.  
  522. /*
  523.  * Move_FocusToPrevInField(-)
  524.  *
  525.  * Purpose:
  526.  * --------
  527.  * Se d‚place vers le PRECEDENT champ de saisie activ‚ de la page
  528.  * en affichant la page vid‚otex associ‚e au passage
  529.  *
  530.  * Suggest:
  531.  * --------
  532.  * Am‚liorer le systŠme register_action: ajouter des paramŠtres
  533.  *
  534.  * History:
  535.  * --------
  536.  * 05.12.94: fplanque: Created
  537.  * 05.01.94: profite des params ACTION
  538.  */
  539. void    Move_FocusToPrevInField(
  540.                 VOIE     *    pVoie_curr )    /* In: Voie concern‚e */
  541. {
  542.     if( pVoie_curr -> pIOField_CurrIn != NULL )
  543.     {    /*
  544.          * S'il y a au moins un champ d'‚dition:
  545.          */
  546.         IOFIELD    *    pInField_Target = pVoie_curr -> pIOField_CurrIn -> p_prev;
  547.  
  548.         if( pInField_Target != NULL )
  549.         {    /*
  550.              * S'il y a un autre champ avant, 
  551.              * on demande d'afficher la page vdt correspondante et d'y aller:
  552.              */
  553.             register_action( pVoie_curr, DISP, pInField_Target -> FPar.Input -> fnct_no, 0, NULL );        
  554.             register_action( pVoie_curr, EFLD, 0, 0, pInField_Target );        
  555.         }
  556.         else
  557.         {    /*
  558.              * On est sur le Premier champ:
  559.              * On le signale:
  560.              */
  561.             aff_msg_l0( pVoie_curr, "Premier champ de saisie!" );
  562.         }
  563.     }
  564.  
  565.     /*
  566.      * Repasse en mode d'attente d'action:
  567.      */
  568.     register_action( pVoie_curr, WAIT, 0, 0, NULL );
  569. }
  570.  
  571.  
  572.  
  573. /*
  574.  * Move_FocusToInField(-)
  575.  *
  576.  * Purpose:
  577.  * --------
  578.  * Se d‚place vers le champ de saisie donn‚ en paramŠtre
  579.  * en affichant la page vid‚otex associ‚e au passage
  580.  *
  581.  * History:
  582.  * --------
  583.  * 13.12.94: fplanque: Created
  584.  * 05.01.95: profite des params ACTION
  585.  */
  586. void    Move_FocusToInField(
  587.                 VOIE         *    pVoie_curr,    /* In: Voie concern‚e */
  588.                 IOFIELD    *    pIOField_In )    /* In: Champ de saisie d‚sir‚ */
  589. {
  590.     if( pIOField_In != NULL )
  591.     {    /*
  592.          * Si champ valide, on demande l'entr‚e ds ce champ:
  593.          */
  594.         register_action( pVoie_curr, DISP, pIOField_In -> FPar.Input -> fnct_no, 0, NULL );        
  595.         register_action( pVoie_curr, EFLD, 0, 0, pIOField_In );        
  596.     }
  597.  
  598.     /*
  599.      * Repasse en mode d'attente d'action:
  600.      */
  601.     register_action( pVoie_curr, WAIT, 0, 0, NULL );
  602. }
  603.  
  604.  
  605.  
  606. /*
  607.  * Move_FocusToInField_byFnct(-)
  608.  *
  609.  * Purpose:
  610.  * --------
  611.  * Se d‚place vers le champ de saisie dont la fonction est donn‚e en param
  612.  * en affichant la page vid‚otex associ‚e au passage
  613.  *
  614.  * History:
  615.  * --------
  616.  * 13.12.94: fplanque: Created
  617.  * 13.02.95: prend fnct diff‚rente pour ‚cran
  618.  */
  619. void    Move_FocusToInField_byFnct(
  620.                 VOIE         *    pVoie_curr,        /* In: Voie concern‚e */
  621.                 int            n_FnctInput,    /* In: Fonction du champ de saisie d‚sir‚ */
  622.                 int            n_FnctEcran )    /* In: Fonction ‚cran d‚sir‚e avant edition du champ */
  623. {
  624.     /*
  625.      * On demande l'entr‚e ds ce champ:
  626.      */
  627.     register_action( pVoie_curr, DISP, n_FnctEcran, 0, NULL );        
  628.     register_action( pVoie_curr, EFLD, n_FnctInput, 0, NULL );        
  629.  
  630.     /*
  631.      * Repasse en mode d'attente d'action:
  632.      */
  633.     register_action( pVoie_curr, WAIT, 0, 0, NULL );
  634. }
  635.  
  636.  
  637. /*
  638.  * aim_CurrField(-)
  639.  *
  640.  * Purpose:
  641.  * --------
  642.  * Obtient ptr sur le texte du champ de saisie courant
  643.  * sur la voie demand‚e
  644.  *
  645.  * SUGGEST:
  646.  * ------
  647.  * What about multiline fields!?
  648.  *
  649.  * History:
  650.  * --------
  651.  * 24.05.94: fplanque: Created
  652.  * 22.08.94: renvoie chaine vide si pas de ligne de commande
  653.  * 05.12.94: returns CONST char *
  654.  */
  655. const char *    aim_CurrField(                /* Out: Ptr sur texte du Champ courant */
  656.                         VOIE *pVoie_curr )    /* In:  Ptr sur voie courante */
  657. {
  658.     /*
  659.      *    Utilise la ligne d'‚dition courante:
  660.      */
  661.     TEXTLINE    *    pTextLine = pVoie_curr -> curr_textline;
  662.     
  663.     if( pTextLine -> text != NULL )
  664.     {
  665.         return    pTextLine -> text;
  666.     }
  667.     
  668.     return    G_empty_string;
  669. }
  670.  
  671.  
  672.  
  673. /*
  674.  * aim_InField(-)
  675.  *
  676.  * Purpose:
  677.  * --------
  678.  * Obtient ptr sur le texte d'un champ de saisie sur la voie demand‚e
  679.  *
  680.  * SUGGEST:
  681.  * ------
  682.  * What about multiline fields!?
  683.  *
  684.  * History:
  685.  * --------
  686.  * 05.12.94: fplanque: Derived from aim_CurrField()
  687.  */
  688. const char * aim_InField(                    /* Out: Ptr sur texte du Champ demand‚ */
  689.                     VOIE *    pVoie_curr,        /* In:  Ptr sur voie courante */
  690.                     int        n_Fnct )            /* In:  Fonction du champ qui nous int‚resse */
  691. {
  692.     IOFIELD    *    pIOField_In;
  693.     char        *    psz_Text;
  694.  
  695.     if( get_InFieldPars( pVoie_curr, n_Fnct, &pIOField_In ) != FLD_READY )
  696.     {    
  697.         return    NULL;
  698.     }
  699.  
  700.     /*
  701.      * Le champ existe et est activ‚:
  702.      */
  703.     psz_Text = pIOField_In -> pTextInfo -> firstline -> next -> text;
  704.     
  705.     if( psz_Text != NULL )
  706.     {
  707.         return    psz_Text;
  708.     }
  709.     
  710.     return    G_empty_string;
  711. }
  712.  
  713.  
  714.  
  715.  
  716. /*
  717.  * validate_InFields(-)
  718.  *
  719.  * Purpose:
  720.  * --------
  721.  * V‚rifie que le cotnenu des champs de saisie est correct
  722.  * 
  723.  * History:
  724.  * --------
  725.  * 09.12.94: fplanque: Created
  726.  */
  727. BOOL    validate_InFields(         /* Out: TRUE si les champ sont correctement remplis */
  728.             VOIE * pVoie_curr )    /* In:  Voie concern‚e */
  729. {
  730.     IOFIELD            *    pIOField_CurrIn = pVoie_curr -> pIOField_ListIn;
  731.  
  732.     while( pIOField_CurrIn != NULL )
  733.     {
  734.         if( pIOField_CurrIn -> FPar.Input -> InFieldFlags.b_Mandatory )
  735.         {    /*
  736.              * Si saisie obligatoire:
  737.              * on contr“le que quelque chose a ‚t‚ saisi ds ce champ:
  738.              */
  739.             if( ! text_IsFilled( pIOField_CurrIn -> pTextInfo ) )
  740.             {    /*
  741.                  * Le champ est vide ou ne contient que des cars <=32
  742.                  */
  743.                 aff_msg_l0( pVoie_curr, "Saisie icomplŠte!" );
  744.                 Move_FocusToInField( pVoie_curr, pIOField_CurrIn );
  745.                 return    FALSE0;                
  746.             }
  747.         }    
  748.     
  749.         /*
  750.          * Passe au champ de saisie suivant:
  751.          */
  752.         pIOField_CurrIn = pIOField_CurrIn -> p_next;
  753.     }
  754.     
  755.     return    TRUE_1;
  756. }
  757.  
  758.  
  759. /*
  760.  * IOFieldList_Destruct(-)
  761.  *
  762.  * Purpose:
  763.  * --------
  764.  * Detruit une liste de IOFields
  765.  * ainsi que les textes formatt‚s qu'elle r‚f‚rence
  766.  *
  767.  * History:
  768.  * --------
  769.  * 18.12.94: fplanque: Created
  770.  */
  771. void    IOFieldList_Destruct(
  772.             IOFIELD    *    pIOField )    /* In: 1er elt de la Liste … effacer */
  773. {
  774.     IOFIELD    * pIOField_next;
  775.  
  776.     while( pIOField != NULL )
  777.     {    /*
  778.          * Tant qu'il y a des champs de saisie … effacer:
  779.          */
  780.         pIOField_next = pIOField -> p_next;
  781.         
  782.         /*
  783.          * LibŠre zone d'‚dition propre … la voie:
  784.          */
  785.         free_formatext( pIOField -> pTextInfo );
  786.         
  787.         pIOField    = pIOField_next;
  788.     }
  789. }
  790.  
  791.  
  792. /*
  793.  * OutField_Display(-)
  794.  *
  795.  * Purpose:
  796.  * --------
  797.  * Affiche un champ d'informations
  798.  *
  799.  * History:
  800.  * --------
  801.  * 18.12.94: fplanque: Created
  802.  * 13.01.95: gŠre l'inverse vid‚o
  803.  * 25.01.95: gŠre offsets
  804.  */
  805. void    OutField_Display(
  806.             VOIE         *    pVoie_curr,        /* In: Voie concern‚e */
  807.             IOFIELD    *    pIOField,        /* In: Champ … afficher */
  808.             int            n_XOffset,        /* In: Offsets … appliquer aux coordonn‚es des champs */            
  809.             int            n_YOffset )
  810. {
  811.     int                device = pVoie_curr -> device;        /* Port utilis‚ */
  812.     OUTPUT_FPAR    *    pOutput_FPar    = pIOField -> FPar.Output;
  813.     TEXTLINE     *    curr_textline    = pIOField -> pTextLine_Top;    /* 1Šre ligne … afficher */
  814.     /*
  815.      * Init Variables: 
  816.      */
  817.     int    x            = pOutput_FPar -> x + n_XOffset;                /* Position x */
  818.     int    y;
  819.     int    col_text = pOutput_FPar -> col_text;    /* Couleur texte */
  820.     OUTFIELD_FLAGS OutFieldFlags = pOutput_FPar -> OutFieldFlags;
  821.  
  822.     /*
  823.      * Affiche le texte: 
  824.      */
  825.     for ( y = pOutput_FPar -> y + n_YOffset; 
  826.             curr_textline != NULL
  827.             &&    y < pOutput_FPar -> y + n_YOffset + pOutput_FPar -> h;
  828.             y++ )
  829.     {    /*
  830.           * Positionne le curseur: 
  831.           */
  832.         pos( device, x, y );
  833.         /*
  834.          * Couleur texte: 
  835.          */
  836.         set_tcolor( device, col_text );    
  837.         /*
  838.          * Inverse vid‚o:
  839.          */
  840.         if( OutFieldFlags .b_ReverseText )
  841.         {
  842.             term_setReverse( device );    
  843.         }
  844.         /*
  845.          * Affiche ligne: 
  846.          */
  847.         if ( curr_textline -> text != NULL )
  848.         {    /*
  849.              * S'il y a du texte sur cette ligne: 
  850.              */
  851.             str_conout ( device, curr_textline -> text );
  852.         }
  853.         
  854.         /*
  855.          * Passe … la ligne suivante: 
  856.          */
  857.         curr_textline = curr_textline -> next;
  858.     }
  859. }
  860.  
  861.  
  862.  
  863.  
  864. /*
  865.  * IOField_MoveTopLine(-)
  866.  *
  867.  * Purpose:
  868.  * --------
  869.  * D‚place la TOpLine d'un champ de saisie/sortie
  870.  * du nombre de lignes d‚sir‚:
  871.  *
  872.  * History:
  873.  * --------
  874.  * 19.12.94: fplanque: Created
  875.  * 06.01.95: retourne nbre de lignes dont on s'est effectivement d‚plac‚
  876.  * 06.01.95: empˆche de s'arrˆter sur la ligne 0
  877.  */
  878. long    IOField_MoveTopLine(                /* Out: Nbre de lignes dont on s'est effectivement d‚plac‚ */
  879.             IOFIELD    *    pIOField,        /* In:  Champ ds lequel on se d‚place */
  880.             long            l_LineOffset )    /* In:  Nbre de lignes duquel on veut se d‚placer */
  881. {
  882.     long            i;
  883.     TEXTLINE    *    pTextLine_Top = pIOField -> pTextLine_Top;
  884.  
  885.     if( l_LineOffset < 0 )
  886.     {
  887.         for( i=0; pTextLine_Top -> prev != NULL && i>l_LineOffset; i-- )
  888.         {
  889.             pTextLine_Top = pTextLine_Top -> prev;
  890.         }
  891.         
  892.         if( pTextLine_Top -> prev == NULL )
  893.         {    /*
  894.              * On ne veut pas s'arrˆter sur la ligne 0!!
  895.              */
  896.             pTextLine_Top = pTextLine_Top -> next;
  897.             i++;
  898.         }
  899.     }
  900.     else
  901.     {
  902.         for( i=0; pTextLine_Top -> next != NULL && i<l_LineOffset; i++ )
  903.         {
  904.             pTextLine_Top = pTextLine_Top -> next;
  905.         }
  906.     }
  907.  
  908.     /*
  909.      * R‚catualise ptr sur ligne au top:
  910.      */
  911.     pIOField -> pTextLine_Top = pTextLine_Top;
  912.     pIOField -> l_TopLine     += i;
  913.  
  914.     return    i;
  915. }
  916.  
  917.  
  918. /*
  919.  * IOField_DisplayText(-)
  920.  *
  921.  * Purpose:
  922.  * --------
  923.  * Affiche un texte dans un champ de sortie
  924.  * (le texte est formatt‚)
  925.  * Mais ne garde aucune trace aprŠs
  926.  *
  927.  * History:
  928.  * --------
  929.  * 10.01.95: fplanque: Created
  930.  */
  931. void    IOField_DisplayText(
  932.             VOIE             *    pVoie_curr,        /* In: Voie concern‚e */
  933.             OUTPUT_FPAR    *    pOutputFPar,    /* In: ParamŠtres du champ de sortie concern‚ */
  934.             int                n_XOffset,        /* In: Offsets … appliquer aux coordonn‚es des champs */            
  935.             int                n_YOffset,
  936.             char            *    pText,            /* In: Texte (compact) … afficher */
  937.             size_t            size_Text )        /* In: Longueur de ce texte */
  938. {
  939.     IOFIELD    IOField;
  940.  
  941.     if( pOutputFPar == NULL || pText == NULL )
  942.     {
  943.         return;
  944.     }
  945.  
  946.     IOField .p_next = NULL;
  947.     IOField .p_prev = NULL;
  948.  
  949.     /*
  950.      * linkage PARAMS d'affichage: 
  951.      */
  952.     IOField .FPar.Output = pOutputFPar;
  953.  
  954.      /*
  955.       * D‚compose texte en lignes:
  956.       */
  957.     IOField .pTextInfo = create_justified_text( pText, size_Text, pOutputFPar -> w );
  958.  
  959.     /*
  960.      * M‚morise ligne au top de la zone d'affichage:
  961.      */
  962.     IOField .pTextLine_Top    = IOField .pTextInfo -> firstline -> next;
  963.     IOField .l_TopLine        = 1;        /* On est sur la ligne no 1 */
  964.  
  965.     /*
  966.      * Affiche le champ:
  967.      */
  968.     OutField_Display( pVoie_curr, &IOField, n_XOffset, n_YOffset );
  969.  
  970.     /*
  971.      * Efface le texte formatt‚ de la m‚moire: 
  972.      */
  973.     IOFieldList_Destruct( &IOField );
  974.  
  975. }
  976.  
  977.  
  978.  
  979. /*
  980.  * IOField_PrepareText(-)
  981.  *
  982.  * Purpose:
  983.  * --------
  984.  * pr‚pare un texte pour son affichge ds un outfield 
  985.  *
  986.  * History:
  987.  * --------
  988.  * 24.01.95: fplanque: Created
  989.  */
  990. IOFIELD *    IOField_PrepareText(
  991.                     OUTPUT_FPAR    *    pOutputFPar,    /* In: ParamŠtres du champ de sortie concern‚ */
  992.                     char            *    pText,            /* In: Texte (compact) … afficher */
  993.                     size_t            size_Text )        /* In: Longueur de ce texte */
  994. {
  995.     IOFIELD *    pIOField;
  996.  
  997.     if( pOutputFPar == NULL || pText == NULL )
  998.     {
  999.         return    NULL;
  1000.     }
  1001.  
  1002.     pIOField = MALLOC( sizeof( IOFIELD ) );
  1003.  
  1004.     pIOField -> p_next = NULL;
  1005.     pIOField -> p_prev = NULL;
  1006.  
  1007.     /*
  1008.      * linkage PARAMS d'affichage: 
  1009.      */
  1010.     pIOField -> FPar.Output = pOutputFPar;
  1011.  
  1012.      /*
  1013.       * D‚compose texte en lignes:
  1014.       */
  1015.     pIOField -> pTextInfo = create_justified_text( pText, size_Text, pOutputFPar -> w );
  1016.  
  1017.     /*
  1018.      * M‚morise ligne au top de la zone d'affichage:
  1019.      */
  1020.     pIOField -> pTextLine_Top    = pIOField -> pTextInfo -> firstline -> next;
  1021.     pIOField -> l_TopLine        = 1;        /* On est sur la ligne no 1 */
  1022.  
  1023.  
  1024.     return    pIOField;
  1025.  
  1026. }
  1027.  
  1028.  
  1029.  
  1030. /*
  1031.  * IOField_DisplayString(-)
  1032.  *
  1033.  * Purpose:
  1034.  * --------
  1035.  * Affiche une chaine dans un champ de sortie
  1036.  * (pas de formattage, 1 ligne maximum)
  1037.  * Mais ne garde aucune trace aprŠs
  1038.  *
  1039.  * History:
  1040.  * --------
  1041.  * 13.01.95: fplanque: Created
  1042.  * 25.01.95: gŠre offsets
  1043.  */
  1044. void    IOField_DisplayString(
  1045.             VOIE             *    pVoie_curr,        /* In: Voie concern‚e */
  1046.             OUTPUT_FPAR    *    pOutputFPar,    /* In: ParamŠtres du champ de sortie concern‚ */
  1047.             int                n_XOffset,        /* In: Offsets … appliquer aux coordonn‚es des champs */            
  1048.             int                n_YOffset,
  1049.             const char    *    cpsz_String )    /* In: Chaine … afficher */
  1050. {
  1051.     int    device = pVoie_curr -> device;        /* Port utilis‚ */
  1052.  
  1053.     if( pOutputFPar == NULL || cpsz_String == NULL )
  1054.     {
  1055.         return;
  1056.     }
  1057.  
  1058.     /* 
  1059.      * Positionne le curseur: 
  1060.      */
  1061.     pos( device, pOutputFPar -> x + n_XOffset, pOutputFPar -> y + n_YOffset );
  1062.     /*
  1063.      * Couleur texte: 
  1064.      */
  1065.     set_tcolor( device, pOutputFPar -> col_text );    
  1066.     /*
  1067.      * Inverse vid‚o:
  1068.      */
  1069.     if( pOutputFPar -> OutFieldFlags .b_ReverseText )
  1070.     {
  1071.         term_setReverse( device );    
  1072.     }
  1073.     /*
  1074.      * Affiche ChaŒne: 
  1075.      */
  1076.     str_nconout( device, cpsz_String, pOutputFPar -> w );
  1077.  
  1078. }
  1079.  
  1080.  
  1081.  
  1082.  
  1083. /*
  1084.  * OutField_Clear(-)
  1085.  *
  1086.  * Purpose:
  1087.  * --------
  1088.  * Efface un champ d'informations de l'‚cran
  1089.  * avec ses attributs par d‚faut
  1090.  *
  1091.  * Notes:
  1092.  * ------
  1093.  *
  1094.  * History:
  1095.  * --------
  1096.  * 13.01.95: fplanque: Created based on OutField_Display()
  1097.  * 25.01.95: gŠre offsets
  1098.  */
  1099. void    OutField_Clear(
  1100.             VOIE             *    pVoie_curr,            /* In: Voie concern‚e */
  1101.             OUTPUT_FPAR    *    pOutput_FPar,    /* In: Param Champ … effacer */
  1102.             int                n_XOffset,            /* In: Offsets … appliquer aux coordonn‚es des champs */            
  1103.             int                n_YOffset )
  1104. {
  1105.     OUTFIELD_FLAGS OutField_Flags = pOutput_FPar -> OutFieldFlags;
  1106.  
  1107.     if( pOutput_FPar != NULL && OutField_Flags.b_enabled  &&  OutField_Flags.b_Clear )
  1108.     {
  1109.         int                device = pVoie_curr -> device;        /* Port utilis‚ */
  1110.         /*
  1111.          * Init Variables: 
  1112.          */
  1113.         int    x            = pOutput_FPar -> x + n_XOffset;        /* Position x */
  1114.         int    w            = pOutput_FPar -> w;                    /* largeur */
  1115.         int    y;
  1116.         int    col_text = pOutput_FPar -> col_text;    /* Couleur texte */
  1117.         OUTFIELD_FLAGS OutFieldFlags = pOutput_FPar -> OutFieldFlags;
  1118.     
  1119.         /*
  1120.          * Affiche le texte: 
  1121.          */
  1122.         for ( y = pOutput_FPar -> y + n_YOffset; 
  1123.                 y < pOutput_FPar -> y + n_YOffset + pOutput_FPar -> h;
  1124.                 y++ )
  1125.         {    /*
  1126.               * Positionne le curseur: 
  1127.               */
  1128.             pos( device, x, y );
  1129.             /*
  1130.              * Couleur texte: 
  1131.              * on doit la fixer pour:
  1132.              * -inverse vid‚o
  1133.              * -s'il y a un soulignement pour que sa couleur soit celle du texte, la ou il n'y a pas de texte!
  1134.              */
  1135.             set_tcolor( device, col_text );    
  1136.             /*
  1137.              * Inverse vid‚o:
  1138.              */
  1139.             if( OutFieldFlags .b_ReverseText )
  1140.             {    /*
  1141.                  * Inverse vid‚o:
  1142.                  */
  1143.                 term_setReverse( device );    
  1144.             }
  1145.     
  1146.             /*
  1147.              * Efface ligne: 
  1148.              */
  1149.             mconout( device, ' ', w );
  1150.         }
  1151.     }
  1152. }
  1153.  
  1154.  
  1155. /*
  1156.  * InField_Clear(-)
  1157.  *
  1158.  * Efface le contenu d'un champ de saisie
  1159.  * et r‚percute … l'‚cran
  1160.  *
  1161.  * 14.05.95: fplanque: Created
  1162.  */
  1163. void InField_Clear(
  1164.             VOIE         *    pVoie_curr,            /* In:    Voie concern‚e */
  1165.             IOFIELD    *    pIOField_CurrIn )    /* In:    Ptr sur champ … effacer */
  1166. {
  1167.     TEXTINFO    *    pTextInfo = pIOField_CurrIn -> pTextInfo;
  1168.     TEXTLINE    *    pTextLine_Top = pTextInfo -> firstline -> next;
  1169.  
  1170.     /*
  1171.      * Ligne au top de la zone d'affichage = 1Šre ligne du champ:
  1172.      */
  1173.     pIOField_CurrIn -> pTextLine_Top  = pTextLine_Top;
  1174.     pIOField_CurrIn -> l_TopLine         = 1;        /* On est sur la ligne no 1 */
  1175.  
  1176.     /*
  1177.      * Vide le contenu de la 1Šre ligne:
  1178.      */
  1179.     pTextLine_Top -> length = 0;                /* Fixe longueur de la ligne */
  1180.     if( pTextLine_Top -> text != NULL )
  1181.     {
  1182.         pTextLine_Top -> text[ 0 ] = '\0';        /* Fin de la ligne! */
  1183.     }
  1184.     
  1185.     /*
  1186.      * Efface les lignes suivantes de la m‚moire:
  1187.      */
  1188.     while( pTextInfo -> lastline != pTextLine_Top )
  1189.     {
  1190.         delete_line( pTextInfo -> lastline, pTextInfo );
  1191.     }
  1192.     
  1193.     /*
  1194.      * -------------------------------------------------
  1195.      * R‚affichage:
  1196.      */
  1197.     display_field( pVoie_curr -> device, pIOField_CurrIn, 0, 1000 );
  1198.  
  1199.     /*
  1200.      * Ligne en cours d'‚dition
  1201.      * (ligne actuellement affich‚e au top de la zone d'‚dition)
  1202.      */
  1203.     pVoie_curr -> curr_textline = pIOField_CurrIn -> pTextLine_Top;
  1204.     pVoie_curr -> l_CurrLine     = pIOField_CurrIn -> l_TopLine;
  1205.     
  1206.     pVoie_curr -> csr_x = pIOField_CurrIn -> FPar.Input -> x +    pVoie_curr -> curr_textline -> length;
  1207.     pVoie_curr -> csr_y = pIOField_CurrIn -> FPar.Input -> y;
  1208.  
  1209.     /*
  1210.      * Place curseur: 
  1211.      */
  1212.     place_csr( pVoie_curr );
  1213. }
  1214.  
  1215.  
  1216. /*
  1217.  * Find_OutField(-)
  1218.  *
  1219.  * Purpose:
  1220.  * --------
  1221.  * Cherche un champ d'affichage dans la page courante 
  1222.  * en fonction de son no de fonction
  1223.  * et renvoie ses paramŠtres
  1224.  *
  1225.  * History:
  1226.  * --------
  1227.  * 24.01.95: fplanque: Created
  1228.  */
  1229. OUTPUT_FPAR    *    Find_OutField(             /* Out: Champ de sortie trouv‚ */
  1230.                         VOIE    *    pVoie_curr,    /* In:  Voie concern‚e */
  1231.                         int        n_fnct )        /* In:  No de fonction demand‚e */
  1232. {
  1233.     PAGEARBO         *    pPageArbo = pVoie_curr -> arboparams;
  1234.     ARBO_FIELDPARS    *     pFieldPars_output = pPageArbo -> output_fields;
  1235.     OUTPUT_FPAR        *    pOutput_FPar;
  1236.  
  1237.     while( pFieldPars_output != NULL )
  1238.     {    /*
  1239.          * En fonction du type de champ:
  1240.          */
  1241.         pOutput_FPar = &(pFieldPars_output -> data.output);
  1242.          
  1243.         if( pFieldPars_output -> data.fnct_no == n_fnct )
  1244.         {
  1245.             return    pOutput_FPar;
  1246.         }
  1247.     
  1248.         /*
  1249.          * Passe au champ suivant:
  1250.          */
  1251.         pFieldPars_output = pFieldPars_output -> next;
  1252.     }
  1253.     
  1254.     return    NULL;
  1255. }
  1256.  
  1257.  
  1258.